/*
    * Copyright (C) 2009 The Guava Authors
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package com.google.common.collect;
  
  import static com.google.common.collect.Lists.transform;
  import static com.google.common.collect.Sets.newHashSet;
  import static com.google.common.collect.Sets.newTreeSet;
  import static java.lang.reflect.Modifier.isPublic;
  import static java.lang.reflect.Modifier.isStatic;
  
  import com.google.common.base.Function;
  import com.google.common.base.Joiner;
  import com.google.common.base.Objects;
  
  import junit.framework.TestCase;
  
  import java.lang.reflect.Method;
  import java.lang.reflect.Type;
  import java.lang.reflect.TypeVariable;
  import java.util.Arrays;
  import java.util.Collections;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  /**
   * Tests that all {@code public static} methods "inherited" from superclasses
   * are "overridden" in each immutable-collection class. This ensures, for
   * example, that a call written "{@code ImmutableSortedSet.copyOf()}" cannot
   * secretly be a call to {@code ImmutableSet.copyOf()}.
   * 
   * @author Chris Povirk
   */
  public class FauxveridesTest extends TestCase {
    public void testImmutableBiMap() {
      doHasAllFauxveridesTest(ImmutableBiMap.class, ImmutableMap.class);
    }
  
    public void testImmutableListMultimap() {
      doHasAllFauxveridesTest(
          ImmutableListMultimap.class, ImmutableMultimap.class);
    }
  
    public void testImmutableSetMultimap() {
      doHasAllFauxveridesTest(
          ImmutableSetMultimap.class, ImmutableMultimap.class);
    }
  
    public void testImmutableSortedMap() {
      doHasAllFauxveridesTest(ImmutableSortedMap.class, ImmutableMap.class);
    }
  
    public void testImmutableSortedSet() {
      doHasAllFauxveridesTest(ImmutableSortedSet.class, ImmutableSet.class);
    }
  
    public void testImmutableSortedMultiset() {
      doHasAllFauxveridesTest(ImmutableSortedMultiset.class, ImmutableMultiset.class);
    }
  
    /*
     * Demonstrate that ClassCastException is possible when calling
     * ImmutableSorted{Set,Map}.copyOf(), whose type parameters we are unable to
     * restrict (see ImmutableSortedSetFauxverideShim).
     */
  
    public void testImmutableSortedMapCopyOfMap() {
      Map<Object, Object> original =
          ImmutableMap.of(new Object(), new Object(), new Object(), new Object());
  
      try {
        ImmutableSortedMap.copyOf(original);
        fail();
      } catch (ClassCastException expected) {
      }
    }
  
    public void testImmutableSortedSetCopyOfIterable() {
      Set<Object> original = ImmutableSet.of(new Object(), new Object());
  
      try {
        ImmutableSortedSet.copyOf(original);
        fail();
      } catch (ClassCastException expected) {
      }
   }
 
   public void testImmutableSortedSetCopyOfIterator() {
     Set<Object> original = ImmutableSet.of(new Object(), new Object());
 
     try {
       ImmutableSortedSet.copyOf(original.iterator());
       fail();
     } catch (ClassCastException expected) {
     }
   }
 
   private void doHasAllFauxveridesTest(Class<?> descendant, Class<?> ancestor) {
     Set<MethodSignature> required = getAllRequiredToFauxveride(ancestor);
     Set<MethodSignature> found = getAllFauxveridden(descendant, ancestor);
     required.removeAll(found);
 
     assertEquals("Must hide public static methods from ancestor classes",
         Collections.emptySet(), newTreeSet(required));
   }
 
   private static Set<MethodSignature> getAllRequiredToFauxveride(Class<?> ancestor) {
     return getPublicStaticMethodsBetween(ancestor, Object.class);
   }
 
   private static Set<MethodSignature> getAllFauxveridden(
       Class<?> descendant, Class<?> ancestor) {
     return getPublicStaticMethodsBetween(descendant, ancestor);
   }
 
   private static Set<MethodSignature> getPublicStaticMethodsBetween(
       Class<?> descendant, Class<?> ancestor) {
     Set<MethodSignature> methods = newHashSet();
     for (Class<?> clazz : getClassesBetween(descendant, ancestor)) {
       methods.addAll(getPublicStaticMethods(clazz));
     }
     return methods;
   }
 
   private static Set<MethodSignature> getPublicStaticMethods(Class<?> clazz) {
     Set<MethodSignature> publicStaticMethods = newHashSet();
 
     for (Method method : clazz.getDeclaredMethods()) {
       int modifiers = method.getModifiers();
       if (isPublic(modifiers) && isStatic(modifiers)) {
         publicStaticMethods.add(new MethodSignature(method));
       }
     }
 
     return publicStaticMethods;
   }
 
   /** [descendant, ancestor) */
   private static Set<Class<?>> getClassesBetween(
       Class<?> descendant, Class<?> ancestor) {
     Set<Class<?>> classes = newHashSet();
 
     while (!descendant.equals(ancestor)) {
       classes.add(descendant);
       descendant = descendant.getSuperclass();
     }
 
     return classes;
   }
 
   /**
    * Not really a signature -- just the parts that affect whether one method is
    * a fauxveride of a method from an ancestor class.
    * <p>
    * See JLS 8.4.2 for the definition of the related "override-equivalent."
    */
   private static final class MethodSignature
       implements Comparable<MethodSignature> {
     final String name;
     final List<Class<?>> parameterTypes;
     final TypeSignature typeSignature;
 
     MethodSignature(Method method) {
       name = method.getName();
       parameterTypes = Arrays.asList(method.getParameterTypes());
       typeSignature = new TypeSignature(method.getTypeParameters());
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof MethodSignature) {
         MethodSignature other = (MethodSignature) obj;
         return name.equals(other.name)
             && parameterTypes.equals(other.parameterTypes)
             && typeSignature.equals(other.typeSignature);
       }
 
       return false;
     }
 
     @Override public int hashCode() {
       return Objects.hashCode(name, parameterTypes, typeSignature);
     }
 
     @Override public String toString() {
       return String.format("%s%s(%s)",
           typeSignature, name, getTypesString(parameterTypes));
     }
 
     @Override public int compareTo(MethodSignature o) {
       return toString().compareTo(o.toString());
     }
   }
 
   private static final class TypeSignature {
     final List<TypeParameterSignature> parameterSignatures;
 
     TypeSignature(TypeVariable<Method>[] parameters) {
       parameterSignatures =
           transform(Arrays.asList(parameters),
               new Function<TypeVariable<?>, TypeParameterSignature>() {
                 @Override
                 public TypeParameterSignature apply(TypeVariable<?> from) {
                   return new TypeParameterSignature(from);
                 }
               });
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof TypeSignature) {
         TypeSignature other = (TypeSignature) obj;
         return parameterSignatures.equals(other.parameterSignatures);
       }
 
       return false;
     }
 
     @Override public int hashCode() {
       return parameterSignatures.hashCode();
     }
 
     @Override public String toString() {
       return (parameterSignatures.isEmpty())
           ? ""
           : "<" + Joiner.on(", ").join(parameterSignatures) + "> ";
     }
   }
 
   private static final class TypeParameterSignature {
     final String name;
     final List<Type> bounds;
 
     TypeParameterSignature(TypeVariable<?> typeParameter) {
       name = typeParameter.getName();
       bounds = Arrays.asList(typeParameter.getBounds());
     }
 
     @Override public boolean equals(Object obj) {
       if (obj instanceof TypeParameterSignature) {
         TypeParameterSignature other = (TypeParameterSignature) obj;
         /*
          * The name is here only for display purposes; <E extends Number> and <T
          * extends Number> are equivalent.
          */
         return bounds.equals(other.bounds);
       }
 
       return false;
     }
 
     @Override public int hashCode() {
       return bounds.hashCode();
     }
 
     @Override public String toString() {
       return (bounds.equals(ImmutableList.of(Object.class)))
           ? name
           : name + " extends " + getTypesString(bounds);
     }
   }
 
   private static String getTypesString(List<? extends Type> types) {
     List<String> names = transform(types, SIMPLE_NAME_GETTER);
     return Joiner.on(", ").join(names);
   }
 
   private static final Function<Type, String> SIMPLE_NAME_GETTER =
       new Function<Type, String>() {
         @Override
         public String apply(Type from) {
           if (from instanceof Class) {
             return ((Class<?>) from).getSimpleName();
           }
           return from.toString();
         }
       };
 }